/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.apache.coyote.http11;

import org.apache.coyote.ActionCode;
import org.apache.coyote.http11.filters.BufferedInputFilter;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.apache.tomcat.util.net.AbstractEndpoint.Handler.SocketState;
import org.apache.tomcat.util.net.JIoEndpoint;
import org.apache.tomcat.util.net.SSLSupport;
import org.apache.tomcat.util.net.SocketStatus;
import org.apache.tomcat.util.net.SocketWrapper;

import java.io.EOFException;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Set;

/**
 * Processes HTTP requests.
 *
 * @author Remy Maucherat
 * @author fhanik
 */
public class Http11Processor extends AbstractHttp11Processor<Socket> {

	private static final Log log = LogFactory.getLog(Http11Processor.class);
	/**
	 * Input.
	 */
	protected InternalInputBuffer inputBuffer = null;

	// ------------------------------------------------------------ Constructor
	/**
	 * Output.
	 */
	protected InternalOutputBuffer outputBuffer = null;


	// ----------------------------------------------------- Instance Variables
	/**
	 * SSL information.
	 */
	protected SSLSupport sslSupport;
	/**
	 * The percentage of threads that have to be in use before keep-alive is
	 * disabled to aid scalability.
	 */
	private int disableKeepAlivePercentage = 75;

	public Http11Processor(int headerBufferSize, JIoEndpoint endpoint, int maxTrailerSize,
	                       Set<String> allowedTrailerHeaders, int maxExtensionSize, int maxSwallowSize) {

		super(endpoint);

		inputBuffer = new InternalInputBuffer(request, headerBufferSize);
		request.setInputBuffer(inputBuffer);

		outputBuffer = new InternalOutputBuffer(response, headerBufferSize);
		response.setOutputBuffer(outputBuffer);

		initializeFilters(maxTrailerSize, allowedTrailerHeaders, maxExtensionSize, maxSwallowSize);
	}

	@Override
	protected Log getLog() {
		return log;
	}

	// --------------------------------------------------------- Public Methods

	/**
	 * Set the SSL information for this HTTP connection.
	 */
	@Override
	public void setSslSupport(SSLSupport sslSupport) {
		this.sslSupport = sslSupport;
	}

	public int getDisableKeepAlivePercentage() {
		return disableKeepAlivePercentage;
	}

	public void setDisableKeepAlivePercentage(int disableKeepAlivePercentage) {
		this.disableKeepAlivePercentage = disableKeepAlivePercentage;
	}

	@Override
	protected boolean disableKeepAlive() {
		int threadRatio = -1;
		// These may return zero or negative values
		// Only calculate a thread ratio when both are >0 to ensure we get a
		// sensible result
		int maxThreads, threadsBusy;
		if ((maxThreads = endpoint.getMaxThreads()) > 0
				&& (threadsBusy = endpoint.getCurrentThreadsBusy()) > 0) {
			threadRatio = (threadsBusy * 100) / maxThreads;
		}
		// Disable keep-alive if we are running low on threads
		if (threadRatio > getDisableKeepAlivePercentage()) {
			return true;
		}

		return false;
	}

	@Override
	protected void setRequestLineReadTimeout() throws IOException {

        /*
         * When there is no data in the buffer and this is not the first
         * request on this connection and timeouts are being used the
         * first read for this request may need a different timeout to
         * take account of time spent waiting for a processing thread.
         * 
         * This is a little hacky but better than exposing the socket
         * and the timeout info to the InputBuffer
         */
		if (inputBuffer.lastValid == 0 && socketWrapper.getLastAccess() > -1) {
			int firstReadTimeout;
			if (keepAliveTimeout == -1) {
				firstReadTimeout = 0;
			} else {
				long queueTime =
						System.currentTimeMillis() - socketWrapper.getLastAccess();

				if (queueTime >= keepAliveTimeout) {
					// Queued for longer than timeout but there might be
					// data so use shortest possible timeout
					firstReadTimeout = 1;
				} else {
					// Cast is safe since queueTime must be less than
					// keepAliveTimeout which is an int
					firstReadTimeout = keepAliveTimeout - (int) queueTime;
				}
			}
			socketWrapper.getSocket().setSoTimeout(firstReadTimeout);
			if (!inputBuffer.fill()) {
				throw new EOFException(sm.getString("iib.eof.error"));
			}
			// Once the first byte has been read, the standard timeout should be
			// used so restore it here.
			if (endpoint.getSoTimeout() > 0) {
				setSocketTimeout(endpoint.getSoTimeout());
			} else {
				setSocketTimeout(0);
			}
		}
	}

	@Override
	protected boolean handleIncompleteRequestLineRead() {
		// Not used with BIO since it uses blocking reads
		return false;
	}

	@Override
	protected void setSocketTimeout(int timeout) throws IOException {
		socketWrapper.getSocket().setSoTimeout(timeout);
	}

	@Override
	protected void setCometTimeouts(SocketWrapper<Socket> socketWrapper) {
		// NO-OP for BIO
	}

	@Override
	protected boolean breakKeepAliveLoop(SocketWrapper<Socket> socketWrapper) {
		openSocket = keepAlive;
		// If we don't have a pipe-lined request allow this thread to be
		// used by another connection
		if (inputBuffer.lastValid == 0) {
			return true;
		}
		return false;
	}

	@Override
	protected void resetTimeouts() {
		// NOOP for BIO
	}

	@Override
	protected void recycleInternal() {
		// Recycle
		this.socketWrapper = null;
		// Recycle ssl info
		sslSupport = null;
	}

	@Override
	public SocketState event(SocketStatus status) throws IOException {
		// Should never reach this code but in case we do...
		throw new IOException(
				sm.getString("http11processor.comet.notsupported"));
	}

	// ----------------------------------------------------- ActionHook Methods

	/**
	 * Send an action to the connector.
	 *
	 * @param actionCode Type of the action
	 * @param param      Action parameter
	 */
	@SuppressWarnings("incomplete-switch") // Other cases are handled by action()
	@Override
	public void actionInternal(ActionCode actionCode, Object param) {

		switch (actionCode) {
			case REQ_SSL_ATTRIBUTE: {
				try {
					if (sslSupport != null) {
						Object sslO = sslSupport.getCipherSuite();
						if (sslO != null)
							request.setAttribute
									(SSLSupport.CIPHER_SUITE_KEY, sslO);
						sslO = sslSupport.getPeerCertificateChain(false);
						if (sslO != null)
							request.setAttribute
									(SSLSupport.CERTIFICATE_KEY, sslO);
						sslO = sslSupport.getKeySize();
						if (sslO != null)
							request.setAttribute
									(SSLSupport.KEY_SIZE_KEY, sslO);
						sslO = sslSupport.getSessionId();
						if (sslO != null)
							request.setAttribute
									(SSLSupport.SESSION_ID_KEY, sslO);
						sslO = sslSupport.getProtocol();
						if (sslO != null) {
							request.setAttribute
									(SSLSupport.PROTOCOL_VERSION_KEY, sslO);
						}
						request.setAttribute(SSLSupport.SESSION_MGR, sslSupport);
					}
				} catch (Exception e) {
					log.warn(sm.getString("http11processor.socket.ssl"), e);
				}
				break;
			}
			case REQ_HOST_ADDR_ATTRIBUTE: {
				if ((remoteAddr == null) && (socketWrapper != null)) {
					InetAddress inetAddr = socketWrapper.getSocket().getInetAddress();
					if (inetAddr != null) {
						remoteAddr = inetAddr.getHostAddress();
					}
				}
				request.remoteAddr().setString(remoteAddr);
				break;
			}
			case REQ_LOCAL_NAME_ATTRIBUTE: {
				if ((localName == null) && (socketWrapper != null)) {
					InetAddress inetAddr = socketWrapper.getSocket().getLocalAddress();
					if (inetAddr != null) {
						localName = inetAddr.getHostName();
					}
				}
				request.localName().setString(localName);
				break;
			}
			case REQ_HOST_ATTRIBUTE: {
				if ((remoteHost == null) && (socketWrapper != null)) {
					InetAddress inetAddr = socketWrapper.getSocket().getInetAddress();
					if (inetAddr != null) {
						remoteHost = inetAddr.getHostName();
					}
					if (remoteHost == null) {
						if (remoteAddr != null) {
							remoteHost = remoteAddr;
						} else { // all we can do is punt
							request.remoteHost().recycle();
						}
					}
				}
				request.remoteHost().setString(remoteHost);
				break;
			}
			case REQ_LOCAL_ADDR_ATTRIBUTE: {
				if (localAddr == null)
					localAddr = socketWrapper.getSocket().getLocalAddress().getHostAddress();

				request.localAddr().setString(localAddr);
				break;
			}
			case REQ_REMOTEPORT_ATTRIBUTE: {
				if ((remotePort == -1) && (socketWrapper != null)) {
					remotePort = socketWrapper.getSocket().getPort();
				}
				request.setRemotePort(remotePort);
				break;
			}
			case REQ_LOCALPORT_ATTRIBUTE: {
				if ((localPort == -1) && (socketWrapper != null)) {
					localPort = socketWrapper.getSocket().getLocalPort();
				}
				request.setLocalPort(localPort);
				break;
			}
			case REQ_SSL_CERTIFICATE: {
				if (sslSupport != null) {
                /*
                 * Consume and buffer the request body, so that it does not
                 * interfere with the client's handshake messages
                 */
					InputFilter[] inputFilters = inputBuffer.getFilters();
					((BufferedInputFilter) inputFilters[Constants.BUFFERED_FILTER])
							.setLimit(maxSavePostSize);
					inputBuffer.addActiveFilter
							(inputFilters[Constants.BUFFERED_FILTER]);
					try {
						Object sslO = sslSupport.getPeerCertificateChain(true);
						if (sslO != null) {
							request.setAttribute
									(SSLSupport.CERTIFICATE_KEY, sslO);
						}
					} catch (Exception e) {
						log.warn(sm.getString("http11processor.socket.ssl"), e);
					}
				}
				break;
			}
			case ASYNC_COMPLETE: {
				if (asyncStateMachine.asyncComplete()) {
					((JIoEndpoint) endpoint).processSocketAsync(this.socketWrapper,
							SocketStatus.OPEN_READ);
				}
				break;
			}
			case ASYNC_SETTIMEOUT: {
				if (param == null) return;
				long timeout = ((Long) param).longValue();
				// if we are not piggy backing on a worker thread, set the timeout
				socketWrapper.setTimeout(timeout);
				break;
			}
			case ASYNC_DISPATCH: {
				if (asyncStateMachine.asyncDispatch()) {
					((JIoEndpoint) endpoint).processSocketAsync(this.socketWrapper,
							SocketStatus.OPEN_READ);
				}
				break;
			}
		}
	}


	// ------------------------------------------------------ Protected Methods

	@Override
	protected void prepareRequestInternal() {
		// NOOP for BIO
	}

	@Override
	protected boolean prepareSendfile(OutputFilter[] outputFilters) {
		// Should never, ever call this code
		Exception e = new Exception();
		log.error(sm.getString("http11processor.neverused"), e);
		return false;
	}

	@Override
	protected AbstractInputBuffer<Socket> getInputBuffer() {
		return inputBuffer;
	}

	@Override
	protected AbstractOutputBuffer<Socket> getOutputBuffer() {
		return outputBuffer;
	}

	/**
	 * Set the socket buffer flag.
	 */
	@Override
	public void setSocketBuffer(int socketBuffer) {
		super.setSocketBuffer(socketBuffer);
		outputBuffer.setSocketBuffer(socketBuffer);
	}
}
